import { H3, serve } from 'h3';
import { DatabaseManager } from './database/index.js';
import { RuleEngine } from './rules/engine.js';
import { ProxyServer } from './proxy/server.js';
import { WebSocketServer } from './websocket/server.js';
import { SystemProxyManager } from './proxy/system-proxy-manager.js';
import { setupApiRoutes } from './apis/index.js';

export class NetworkFirewallApp {
  constructor() {
    this.config = {
      enabled: true,
      port: 12300,
      httpsPort: 12310,
      interceptHttps: true // 启用HTTPS拦截
    };

    // 初始化组件
    this.database = new DatabaseManager();
    this.ruleEngine = new RuleEngine();
    this.webSocketServer = new WebSocketServer();
    this.systemProxyManager = new SystemProxyManager('localhost', this.config.port);
    this.proxyServer = new ProxyServer(
      this.config,
      this.database,
      this.ruleEngine,
      this.webSocketServer
    );

    this.apiServer = null;
    this.isRunning = false;

    // 加载规则
    this.loadRules();
  }

  async start() {
    try {
      console.log('🚀 正在启动网络防火墙应用...');

      // 启动WebSocket服务器
      console.log('📡 正在启动WebSocket服务器...');
      await this.webSocketServer.start(12290);

      // 启动代理服务
      await this.startProxy();

      // 启动API服务器
      console.log('🔧 正在启动API服务器...');
      await this.startApiServer();

      this.isRunning = true;
      console.log('✅ 所有服务启动成功');

    } catch (error) {
      console.error('❌ 启动应用失败:', error);
      // 如果启动失败，尝试恢复系统代理
      try {
        await this.systemProxyManager.restoreSystemProxy();
      } catch (restoreError) {
        console.error('❌ 恢复系统代理失败:', restoreError);
      }
      throw error;
    }
  }

  async startProxy() {
    try {
      console.log('🚀 正在启动代理服务...');

      // 启动代理服务器
      console.log('🌐 正在启动代理服务器...');
      if (!this.proxyServer.isRunning) {
        console.log('🔍 代理服务器当前状态: 未运行，开始启动...');
        await this.proxyServer.start();
        console.log('✅ 代理服务器启动成功');
      } else {
        console.log('ℹ️ 代理服务器已在运行');
      }

      // 设置系统代理
      console.log('🔧 正在设置系统代理...');
      const currentStatus = this.systemProxyManager.getStatus();
      console.log('🔍 当前系统代理状态:', currentStatus);
      
      if (!currentStatus.isProxySet) {
        console.log('🔧 开始设置系统代理...');
        const success = await this.systemProxyManager.setSystemProxy();
        if (!success) {
          throw new Error('设置系统代理失败');
        }
        console.log('✅ 系统代理设置成功');
      } else {
        console.log('ℹ️ 系统代理已设置');
      }

      console.log('✅ 代理服务已启动');

    } catch (error) {
      console.error('❌ 启动代理服务失败:', error);
      console.error('❌ 错误详情:', error.stack);
      // 如果启动失败，尝试恢复系统代理
      try {
        console.log('🔄 尝试恢复系统代理...');
        await this.systemProxyManager.restoreSystemProxy();
      } catch (restoreError) {
        console.error('❌ 恢复系统代理失败:', restoreError);
      }
      throw error;
    }
  }

  async stopProxy() {
    try {
      console.log('🛑 正在停止代理服务...');

      // 使用统一的代理清理逻辑
      if (this.systemProxyManager) {
        await this.cleanupSystemProxy();
      }

      // 停止代理服务器
      if (this.proxyServer) {
        await this.proxyServer.stop();
      }

      console.log('✅ 代理服务已安全停止');

    } catch (error) {
      console.error('❌ 停止代理服务失败:', error);
      // 即使停止失败，也要尝试应急恢复
      await this.emergencyCleanupSystemProxy();
      throw error;
    }
  }

  /**
   * 统一的系统代理清理方法
   */
  async cleanupSystemProxy() {
    try {
      console.log('🔄 开始清理系统代理设置...');
      
      // 使用增强版的恢复逻辑
      const success = await this.systemProxyManager.restoreSystemProxy();
      
      if (success) {
        console.log('✅ 系统代理清理成功');
        
        // 清理网络缓存确保设置生效
        await this.clearNetworkCache();
        
      } else {
        console.warn('⚠️ 系统代理清理失败，执行应急清理');
        await this.emergencyCleanupSystemProxy();
      }
      
    } catch (error) {
      console.error('❌ 系统代理清理失败:', error.message);
      await this.emergencyCleanupSystemProxy();
    }
  }

  /**
   * 应急系统代理清理方法
   */
  async emergencyCleanupSystemProxy() {
    try {
      console.log('🚨 执行应急系统代理清理...');
      
      if (this.systemProxyManager) {
        const success = await this.systemProxyManager.emergencyRestore();
        
        if (success) {
          console.log('✅ 应急系统代理清理成功');
          
          // 额外的清理步骤：清理网络缓存
          await this.clearNetworkCache();
          
        } else {
          console.error('❌ 应急系统代理清理失败');
          console.log('🔧 请手动清理系统代理设置或运行应急恢复脚本: node emergency-restore.js');
        }
      }
      
    } catch (error) {
      console.error('❌ 应急系统代理清理失败:', error.message);
      console.log('🔧 请手动清理系统代理设置或运行应急恢复脚本: node emergency-restore.js');
    }
  }

  /**
   * 清理网络缓存和DNS
   */
  async clearNetworkCache() {
    try {
      console.log('🧹 清理网络缓存和DNS...');
      
      if (process.platform === 'win32') {
        const cleanupCommands = [
          // 清理DNS缓存
          'ipconfig /flushdns',
          // 清理ARP缓存
          'arp -d *',
          // 清理NetBIOS名称缓存
          'nbtstat -R',
          // 清理NetBIOS名称统计
          'nbtstat -RR'
        ];

        for (const command of cleanupCommands) {
          try {
            const { exec } = await import('child_process');
            const { promisify } = await import('util');
            const execAsync = promisify(exec);
            
            await execAsync(command);
            console.log(`✅ 执行清理命令成功: ${command}`);
          } catch (error) {
            console.warn(`⚠️ 清理命令失败: ${command} - ${error.message}`);
          }
        }
        
        console.log('✅ 网络缓存清理完成');
      }
      
    } catch (error) {
      console.warn('⚠️ 清理网络缓存失败:', error.message);
    }
  }

  async stop() {
    try {
      console.log('🛑 正在停止应用...');

      // 先停止代理服务
      await this.stopProxy();

      // 停止WebSocket服务器
      if (this.webSocketServer) {
        this.webSocketServer.stop();
      }

      // 停止API服务器
      if (this.apiServer) {
        await this.apiServer.close();
      }

      // 关闭数据库
      if (this.database) {
        this.database.close();
      }

      this.isRunning = false;
      console.log('✅ 应用已安全停止');

    } catch (error) {
      console.error('❌ 停止应用失败:', error);
      // 确保系统代理被清理
      await this.emergencyCleanupSystemProxy();
      throw error;
    }
  }

  /**
   * 同步停止方法 - 用于进程退出时的快速清理
   */
  stopSync() {
    try {
      console.log('🛑 正在同步停止应用...');

      // 同步停止代理服务
      this.stopProxySync();

      // 停止WebSocket服务器
      if (this.webSocketServer) {
        this.webSocketServer.stop();
      }

      // 停止API服务器
      if (this.apiServer) {
        try {
          this.apiServer.close();
        } catch (error) {
          console.warn('⚠️ API服务器关闭失败:', error.message);
        }
      }

      // 关闭数据库
      if (this.database) {
        this.database.close();
      }

      this.isRunning = false;
      console.log('✅ 应用已同步停止');

    } catch (error) {
      console.error('❌ 同步停止应用失败:', error);
      // 确保系统代理被清理
      this.emergencyCleanupSystemProxySync();
      throw error;
    }
  }

  /**
   * 同步停止代理服务
   */
  stopProxySync() {
    try {
      console.log('🛑 正在同步停止代理服务...');

      // 使用统一的代理清理逻辑
      if (this.systemProxyManager) {
        this.cleanupSystemProxySync();
      }

      // 停止代理服务器
      if (this.proxyServer) {
        this.proxyServer.stopSync();
      }

      console.log('✅ 代理服务已同步停止');

    } catch (error) {
      console.error('❌ 同步停止代理服务失败:', error);
      // 即使停止失败，也要尝试应急恢复
      this.emergencyCleanupSystemProxySync();
      throw error;
    }
  }

  /**
   * 同步系统代理清理方法
   */
  cleanupSystemProxySync() {
    try {
      console.log('🔄 开始同步清理系统代理设置...');
      
      // 使用增强版的恢复逻辑
      const success = this.systemProxyManager.restoreSystemProxySync();
      
      if (success) {
        console.log('✅ 系统代理同步清理成功');
        
        // 清理网络缓存确保设置生效
        this.clearNetworkCacheSync();
        
      } else {
        console.warn('⚠️ 系统代理同步清理失败，执行应急清理');
        this.emergencyCleanupSystemProxySync();
      }
      
    } catch (error) {
      console.error('❌ 系统代理同步清理失败:', error.message);
      this.emergencyCleanupSystemProxySync();
    }
  }

  /**
   * 同步应急系统代理清理方法
   */
  emergencyCleanupSystemProxySync() {
    try {
      console.log('🚨 执行同步应急系统代理清理...');
      
      if (this.systemProxyManager) {
        const success = this.systemProxyManager.emergencyRestoreSync();
        
        if (success) {
          console.log('✅ 同步应急系统代理清理成功');
          
          // 额外的清理步骤：清理网络缓存
          this.clearNetworkCacheSync();
          
        } else {
          console.error('❌ 同步应急系统代理清理失败');
          console.log('🔧 请手动清理系统代理设置或运行应急恢复脚本: node emergency-restore.js');
        }
      }
      
    } catch (error) {
      console.error('❌ 同步应急系统代理清理失败:', error.message);
      console.log('🔧 请手动清理系统代理设置或运行应急恢复脚本: node emergency-restore.js');
    }
  }

  /**
   * 同步清理网络缓存和DNS
   */
  clearNetworkCacheSync() {
    try {
      console.log('🧹 同步清理网络缓存和DNS...');
      
      if (process.platform === 'win32') {
        const { execSync } = require('child_process');
        
        const cleanupCommands = [
          // 清理DNS缓存
          'ipconfig /flushdns',
          // 清理ARP缓存
          'arp -d *',
          // 清理NetBIOS名称缓存
          'nbtstat -R',
          // 清理NetBIOS名称统计
          'nbtstat -RR'
        ];

        for (const command of cleanupCommands) {
          try {
            execSync(command, { timeout: 3000, stdio: 'pipe' });
            console.log(`✅ 执行清理命令成功: ${command}`);
          } catch (error) {
            console.warn(`⚠️ 清理命令失败: ${command} - ${error.message}`);
          }
        }
        
        console.log('✅ 网络缓存同步清理完成');
      }
      
    } catch (error) {
      console.warn('⚠️ 同步清理网络缓存失败:', error.message);
    }
  }

  async startApiServer() {
    try {
      console.log('🔧 开始启动API服务器...');
      
      // 创建H3应用实例
      const app = new H3();

      console.log('🔧 设置API路由...');
      // 设置所有API路由
      setupApiRoutes(this, app);

      console.log('🔧 启动HTTP监听器...');
      // 启动API服务器
      const server = serve(app, {
        port: 12280,
        host: '0.0.0.0'
      });
      
      this.apiServer = server;
      this.startTime = Date.now();
      console.log('✅ API服务器启动成功: http://0.0.0.0:12280 (可通过 http://localhost:12280 或 http://127.0.0.1:12280 访问)');
    } catch (error) {
      console.error('❌ API服务器启动失败:', error);
      throw error;
    }
  }

  loadRules() {
    try {
      // 从数据库加载规则
      const rules = this.database.getRules();
      rules.forEach(rule => {
        this.ruleEngine.addRule(rule);
      });

      console.log(`📋 已加载 ${rules.length} 个规则`);

      // 如果没有规则，创建示例规则
      if (rules.length === 0) {
        console.log('📋 创建示例规则...');
        const exampleRules = this.ruleEngine.createExampleRules();
        exampleRules.forEach(rule => {
          this.database.saveRule(rule);
        });
      }

    } catch (error) {
      console.error('❌ 加载规则失败:', error);
    }
  }

  getStatus() {
    return {
      running: this.isRunning,
      config: this.config,
      services: {
        proxy: this.proxyServer?.getStatus(),
        websocket: {
          clients: this.webSocketServer?.getClientCount() || 0
        },
        database: this.database?.getStats()
      }
    };
  }
} 